{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://raw.githubusercontent.com/Qiskit/qiskit-tutorials/master/images/qiskit-heading.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _*A Monty Hall Problem Solver*_ \n",
    "\n",
    "The latest version of this notebook is available on https://github.com/qiskit/qiskit-tutorial.\n",
    "\n",
    "For more information about how to use the IBM Q experience (QX), consult the [tutorials](https://quantumexperience.ng.bluemix.net/qstage/#/tutorial?sectionId=c59b3710b928891a1420190148a72cce&pageIndex=0), or check out the [community](https://quantumexperience.ng.bluemix.net/qstage/#/community).\n",
    "\n",
    "***\n",
    "### Contributors\n",
    "Pierre Decoodt, Université Libre de Bruxelles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# useful additional packages \n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import time\n",
    "from pprint import pprint\n",
    "\n",
    "# importing Qiskit\n",
    "from qiskit import Aer, IBMQ\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.load_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "The Monty Hall problem has been approached by various formulations related to quantum game theory (notably Fittney and Abbott 2002, D'Ariano et al., 2002). It is no wonder that Alice and Bob come now on stage, the first as the game master, the second as the player.\n",
    "\n",
    "In this tutorial, a quantum model of the Monty Hall's game adapted for the ibmqx5 architecture will be built in three phases.\n",
    "\n",
    "To begin, a circuit comprising two sets of three qubits entangled in a state W will be used to materialize the actions of Alice and Bob and tested in a simulation of the game.\n",
    "\n",
    "In a second step, three Toffoli gates will be added to this circuit to establish a solution in which the measurement of a single qubit a sufficient number of run will be enough to determine the chances of gain Bob according to whether he prefers to stick with his first intention or switch.\n",
    "\n",
    "In a final step, Bob's mood for sticking or switching will gradually change from one experiment to the next to see how this can modify his probability of winning.\n",
    "\n",
    "Let's start by choosing the backend first. A simulator is always preferable during the first tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your choice for the backend is:  ibmq_qasm_simulator\n"
     ]
    }
   ],
   "source": [
    "#can be very slow when number of shoots increases\n",
    "backend = Aer.get_backend('qasm_simulator') \n",
    "\n",
    "# using IBMQ\n",
    "# backend = IBMQ.get_backend('ibmq_qasm_simulator') \n",
    "\n",
    "print(\"Your choice for the backend is: \", backend.name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The  game circuit\n",
    "\n",
    "The first circuit presented here established first two W states with the help of the $ F $ gates described in the tutorial \"W State 1 - Multi-Qubit Systems\". These W states serve as true random number generators.\n",
    "\n",
    "The first W state involving the qubits $q_l$, $q_c$ and $q_r$ represents Alice's choice of the door behind which to hide the car (in the following two equations, the subscrits $l$, $c$ and $r$ represents respectively the left, center and right door):\n",
    "\n",
    "$$ |W \\rangle \\:=\\:\\frac{1}{\\sqrt{3}} \\: (|1_l 0_c 0_r \\rangle \\: + \\: |0_l 1_c 0_r\\rangle \\: +\\:  |0_l 0_c 1_r\\rangle) $$\n",
    "\n",
    "The second W state involving the qubits $q_l^{*}$, $q_c^{*}$ and $q_r^{*}$ represents Bob's initial choice regarding the door behind which the car would hide:\n",
    "\n",
    "$$ |W^{*} \\rangle \\: =\\: \\frac{1}{\\sqrt{3}} \\: (|1_{l}^{*} 0_{c}^{*} 0_{r}^{*} \\rangle \\: + \\: |0_{l}^{*} 1_{c}^{*} 0_{r}^{*}\\rangle \\: +\\:  |0_{l}^{*} 0_{c}^{*} 1_{r}^{*}\\rangle) $$\n",
    "\n",
    "\n",
    "\n",
    "A second true random number generator uses a two-qubit state to simulate coin tossing:\n",
    "\n",
    "$$ H^{\\otimes 2}|0_{a}0_{b}\\rangle=|+_{a}\\rangle \\:|+_{b}\\rangle=\\frac{|0_{a}\\rangle|0_{b}\\rangle+|0_{a}\\rangle|1_{b}\\rangle+|1_{a}\\rangle|0_{b}\\rangle+|1_{a}\\rangle|1_{b}\\rangle}{2}$$\n",
    "\n",
    "As explained in the tutorial \"W State 2 - Let's Make a Deal\", its role is to simulate Alice's choice of the door to open between two doors hiding a goat, when necessary.\n",
    "\n",
    "A last circuit establishes a flag $q_s$ representing Bob's decision to stick with his initial choice (ground state) or to switch (excited state). A Hadamard gate applied to $q_s$  ensures the equiprobability of these possibilities.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a F_gate\n",
    "def F_gate(circ,q,i,j,n,k) :\n",
    "    theta = np.arccos(np.sqrt(1/(n-k+1)))\n",
    "    circ.ry(-theta,q[j])       \n",
    "    circ.cz(q[i],q[j])\n",
    "    circ.ry(theta,q[j])\n",
    "    circ.barrier(q[i])\n",
    "# Define the cxrv gate which uses reverse CNOT instead of CNOT\n",
    "def  cxrv(circ,q,i,j) :\n",
    "    circ.h(q[i])\n",
    "    circ.h(q[j])\n",
    "    circ.cx(q[j],q[i])\n",
    "    circ.h(q[i])\n",
    "    circ.h(q[j])\n",
    "    circ.barrier(q[i],q[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create quantum register\n",
    "q = QuantumRegister(16)\n",
    "# create classical register\n",
    "c = ClassicalRegister(16)\n",
    "# create quantim circuit\n",
    "twin = QuantumCircuit(q, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First W state\n",
    "twin.x(q[14])\n",
    "F_gate(twin,q,14,3,3,1)\n",
    "F_gate(twin,q,3,2,3,2)\n",
    "twin.cx(q[3],q[14])\n",
    "twin.cx(q[2],q[3])\n",
    "\n",
    "#Second W state\n",
    "twin.x(q[12])\n",
    "F_gate(twin,q,12,5,3,1)\n",
    "F_gate(twin,q,5,6,3,2)\n",
    "cxrv(twin,q,5,12)\n",
    "twin.cx(q[6],q[5])\n",
    "\n",
    "#Coin tossing\n",
    "twin.h(q[0])\n",
    "twin.h(q[1])\n",
    "\n",
    "switch1 = QuantumCircuit(q, c, name='switch1')\n",
    "#Stick or switch\n",
    "switch1.h(q[13])\n",
    "\n",
    "for i in range (4) :\n",
    "    switch1.measure(q[i] , c[i]);\n",
    "for i in range (5,7) :\n",
    "    switch1.measure(q[i] , c[i]);\n",
    "for i in range (12,15) :\n",
    "    switch1.measure(q[i] , c[i]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alice and Bob playing\n",
    "\n",
    "Now we're going to watch Alice and Bob in their re-enactment of the TV show \"Let's Make a Deal\".\n",
    "\n",
    "Among the possible scenarios, the one selected is obtained by a one shot execution of the addition of the two circuits described above.\n",
    "\n",
    "Note that a virtual referee checks if one and only one car has been hidden by Alice and if Bob first chooses one and only one door. The program is rerun until a consistent result is achieved. This verification is only useful on real quantum computer.\n",
    "\n",
    "From the result of the measurements of the nine qubits involved, the match is reconstituted on a conventional computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice vs Bob backend= ibmq_qasm_simulator starting time 09/10/2018 10:03:06\n",
      "Alice vs Bob backend= ibmq_qasm_simulator      end time 09/10/2018 10:03:06\n",
      " \n",
      "Alice:       One car and two goats are now hidden behind these doors.\n",
      "             Which door do you choose?\n",
      " \n",
      "Bob:         My choice is the left door\n",
      " \n",
      "Alice:       Now I open the central door and you see a goat\n",
      "             You get an opportunity to change your choice!\n",
      "             Do you want to switch for the right door?\n",
      " \n",
      "Bob:         I change my mind and choose the right door\n",
      "\n",
      "Alice:       You opened the right door and won the car! Congratulations!\n",
      "Game over\n"
     ]
    }
   ],
   "source": [
    "# create AliceBob circuit\n",
    "AliceBob = twin+switch1\n",
    "\n",
    "Label = [\"left\", \"central\", \"right\"]\n",
    "wstates = 0\n",
    "\n",
    "while wstates != 1:\n",
    "    time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "    print(\"Alice vs Bob\", \"backend=\", backend, \"starting time\", time_exp)\n",
    "    result = execute(AliceBob, backend=backend, shots=1)\n",
    "    time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "    print(\"Alice vs Bob\", \"backend=\", backend, \"     end time\", time_exp)\n",
    "    \n",
    "    cstr = str(result.result().get_counts(AliceBob))\n",
    "    nb_of_cars = int(cstr[3]) + int(cstr[14]) + int(cstr[15])\n",
    "    nb_of_doors = int(cstr[12]) + int(cstr[11]) + int(cstr[5])\n",
    "    wstates = nb_of_cars * nb_of_doors\n",
    "\n",
    "print(\" \")\n",
    "print('Alice:       One car and two goats are now hidden behind these doors.')\n",
    "print('             Which door do you choose?')\n",
    "print(\" \")\n",
    "\n",
    "\"Chosing the left door\"\n",
    "if int(cstr[5]) == 1:\n",
    "    Doorchosen = 1\n",
    "\n",
    "\"Chosing the center door\"\n",
    "if int(cstr[11]) == 1:   \n",
    "    Doorchosen = 2\n",
    "    \n",
    "\"Chosing the right door\"\n",
    "if int(cstr[12]) == 1:\n",
    "    Doorchosen = 3\n",
    "\n",
    "time.sleep(2)    \n",
    "print('Bob:         My choice is the',Label[Doorchosen-1], \"door\")\n",
    "print(\" \")\n",
    "\n",
    "randomnb = int(cstr[16]) + int(cstr[17]) %2\n",
    "\n",
    "if cstr[3] == \"1\":    #car behind left door \n",
    "    Doorwinning = 1\n",
    "    if Doorchosen == 1: \n",
    "        Dooropen = 2 + randomnb\n",
    "        Doorswitch = 3 - randomnb\n",
    "    if Doorchosen == 2:\n",
    "        Dooropen = 3 \n",
    "        Doorswitch = 1\n",
    "    if Doorchosen == 3:\n",
    "        Dooropen = 2\n",
    "        Doorswitch = 1    \n",
    "               \n",
    "if cstr[14] == \"1\":     #car behind central door \n",
    "    Doorwinning = 2\n",
    "    if Doorchosen == 2:\n",
    "        Dooropen = 1 + 2*randomnb \n",
    "        Doorswitch = 3 - 2*randomnb \n",
    "    if Doorchosen == 1: \n",
    "        Dooropen = 3\n",
    "        Doorswitch = 2\n",
    "    if Doorchosen == 3:   \n",
    "        Dooropen = 1\n",
    "        Doorswitch = 2\n",
    "        \n",
    "if cstr[15] == \"1\":     #car behind right door \n",
    "    Doorwinning = 3\n",
    "    if Doorchosen == 3:\n",
    "        Dooropen = randomnb + 1\n",
    "        Doorswitch = 2 - randomnb\n",
    "    if Doorchosen == 1: \n",
    "        Dooropen = 2\n",
    "        Doorswitch = 3\n",
    "    if Doorchosen == 2:   \n",
    "        Dooropen = 1\n",
    "        Doorswitch = 3\n",
    "        \n",
    "time.sleep(2)           \n",
    "print('Alice:       Now I open the', Label[Dooropen-1], 'door and you see a goat')\n",
    "time.sleep(2)\n",
    "print('             You get an opportunity to change your choice!')\n",
    "time.sleep(2)\n",
    "print('             Do you want to switch for the',Label[Doorswitch-1], \"door?\")\n",
    "print(\" \")\n",
    "time.sleep(2)\n",
    "\n",
    "switch_flag = int(cstr[4])\n",
    "    \n",
    "\"BOB STICKS WITH HIS FIRST CHOICE!\"\n",
    "if switch_flag == 0:\n",
    "    Doorfinal = Doorchosen\n",
    "    print('Bob:         I stick with my first choice, the',Label[Doorfinal-1], \"door\")\n",
    "                \n",
    "\"BOB CHANGES HIS MIND!\"\n",
    "if switch_flag == 1:\n",
    "    Doorfinal = Doorswitch\n",
    "    print('Bob:         I change my mind and choose the',Label[Doorfinal-1], \"door\")\n",
    "\n",
    "\"FINAL ANNOUNCE\"\n",
    "if Doorfinal == Doorwinning:\n",
    "    endmessage = 'won the car! Congratulations!'\n",
    "else:\n",
    "    endmessage = 'won a goat! Sorry!'\n",
    "\n",
    "time.sleep(2)\n",
    "print()\n",
    "print('Alice:       You opened the',Label[Doorfinal-1],'door and', endmessage)\n",
    "    \n",
    "print(\"Game over\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Toffoli is called on\n",
    "\n",
    "One could claim that during this match the quantum computer plays against itself. However, it should be noted that, in the initial phase, it could have been used repetitively rather than in a single run, for the successive determination of $|W \\rangle$, $|W^{*} \\rangle$, coin tossing and the switch flag.\n",
    "\n",
    "Similarly, two quantum computers such as ibmqx2 and ibmqx4 could have been used, one attributed to Alice and the other to Bob.\n",
    "\n",
    "To take the step towards the quantum computer playing against itself autonomously and keeping track of the result, we need a circuit extension.\n",
    "\n",
    "Here we use three Toffoli gates who have as a common target a qubit $q_w$.  When $q_w$ is in excited state, it indicates the victory of Bob .\n",
    "\n",
    "The description of a Toffoli $C3$ gate is available in the \"Quantum gates and linear algebra\" Jupyter notebook of the Qiskit tutorial.\n",
    "\n",
    "The following three operations are performed$^1$: \n",
    "\n",
    "Left door: $$C3\\;(q_{l},\\;q^{*}_{l},\\;q_w)$$\n",
    "Central door: $$C3\\;(q_{c},\\;q^{*}_{c},\\;q_w)$$\n",
    "Right door: $$C3\\;(q_{r},\\;q^{*}_{r},\\;q_w)$$\n",
    "\n",
    "The end result is that $q_w$ is in excited state iff either $q_{l}=q^{*}_{l}$ or $q_{c}=q^{*}_{c}$ or $q_{r}=q^{*}_{r}$.\n",
    "\n",
    "$^1$ The order of these operations does not matter but is dictated by the architecture of the quantum computer and the $SWAP$ gates needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.extensions.standard.ccx.ToffoliGate at 0x239f937d2e8>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Toffoli gates\n",
    "Toffoli = QuantumCircuit(q, c, name='Toffoli')\n",
    "Toffoli.ccx(q[3], q[5], q[4])\n",
    "Toffoli.swap(q[2],q[3])\n",
    "Toffoli.swap(q[6],q[5])\n",
    "Toffoli.ccx(q[3], q[5], q[4])\n",
    "Toffoli.swap(q[3],q[14])\n",
    "Toffoli.swap(q[12],q[5])\n",
    "Toffoli.ccx(q[3], q[5], q[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A general solution where chance leads the game\n",
    "\n",
    "The addition of the $C3$ gates and a last $cNOT$ gate with $q_s$ as control and $q_w$ as target makes it possible to determine experimentally the probability of winning for systematic sticking and systematic switching strategies. It suffices to measure $q_s$ and $q_w$ a sufficient number of shots.\n",
    "\n",
    "Indeed, for Bob, switching is enough to turn a defeat into a victory and vice versa. \n",
    "\n",
    "Let's look at the results of this experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ibmq_qasm_simulator shots 1024 starting time 09/10/2018 09:46:52\n",
      "ibmq_qasm_simulator shots 1024 end time 09/10/2018 09:46:52\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000000000000000': 351, '0000000000010000': 172, '0010000000010000': 348, '0010000000000000': 153}\n",
      "Proportion sticking:   0.51 \n",
      "Proportion switching:   0.49 \n",
      "Proportion winning when sticking:    0.33 \n",
      "Proportion winning when switching:   0.69 \n"
     ]
    }
   ],
   "source": [
    "# A general solution with 50% switching strategy\n",
    "switch_fifty_percent =QuantumCircuit(q,c, name='switch_fifty_percent')\n",
    "#switch flag\n",
    "switch_fifty_percent.h(q[13])\n",
    "switch_fifty_percent.cx(q[13],q[4])\n",
    "switch_fifty_percent.measure(q[4] , c[4]);\n",
    "switch_fifty_percent.measure(q[13] , c[13]);\n",
    "general_solution = twin+Toffoli+switch_fifty_percent\n",
    "\n",
    "shots = 1024\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(backend, \"shots\",  shots, \"starting time\", time_exp)\n",
    "result = execute(general_solution, backend=backend, shots=shots)\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(backend, \"shots\",  shots, \"end time\", time_exp)\n",
    "plot_histogram(result.result().get_counts(general_solution))\n",
    "print(result.result().get_counts(general_solution))\n",
    "observable_stickwon =  {'0000000000010000': 1, '0010000000010000': 0, '0010000000000000': 0, '0000000000000000': 0}\n",
    "observable_switchwon = {'0000000000010000': 0, '0010000000010000': 1, '0010000000000000': 0, '0000000000000000': 0}\n",
    "observable_stickall =  {'0000000000010000': 1, '0010000000010000': 0, '0010000000000000': 0, '0000000000000000': 1}\n",
    "observable_switchall = {'0000000000010000': 0, '0010000000010000': 1, '0010000000000000': 1, '0000000000000000': 0}\n",
    "stickwon = result.result().average_data(general_solution,observable_stickwon)\n",
    "switchwon = result.result().average_data(general_solution,observable_switchwon)\n",
    "stickall = result.result().average_data(general_solution,observable_stickall)\n",
    "switchall = result.result().average_data(general_solution,observable_switchall)\n",
    "print(\"Proportion sticking: %6.2f \" % stickall)\n",
    "print(\"Proportion switching: %6.2f \" % switchall)\n",
    "stickwon_stickall = stickwon/stickall\n",
    "switchwon_switchall = switchwon/switchall\n",
    "print(\"Proportion winning when sticking:  %6.2f \" % stickwon_stickall)\n",
    "print(\"Proportion winning when switching: %6.2f \" % switchwon_switchall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Mood of Bob\n",
    "\n",
    "After this experimental demonstration of the superiority of the strategy of systematic switching on systematic sticking, in agreement with a theory that is highly counterintuitive but certainly mathematically correct and generally accepted, one could consider that all is said and done.\n",
    "\n",
    "However, it has not been experimentally demonstrated in this tutorial that there is not yet a better strategy between these two extremes. In order to reach a final conclusion, a series of experiments will follow, in which a gradual variation of the switch probability $P(s)$ is created. This equates to a gradual change in Bob's mood, from a propensity to stick with his first choice to an impetuous need to change his mind when given the opportunity.\n",
    "\n",
    "To do this, the qubit $q_s$ undergoes an incremental rotation around X-axis $R_x(\\lambda)$, according to the formula:\n",
    "\n",
    "$$\\lambda = 2\\arcsin \\sqrt{P(s)}$$\n",
    "\n",
    "Since the circuit is  completed by a $cNOT$ gate with $q_s$ as control and $q_w$ as target, the  measure of $q_w$ alone is sufficient to estimate the probability that Bob will win for a given propensity to switch.\n",
    "\n",
    "Here are the results of eight experiments with incremental values of $P(s)$, each with a sufficient number of shots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ibmq_qasm_simulator shots 1024 starting time 09/10/2018 09:47:52\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF93E7F0>  Proportion switching:  0.000   Proportion winning:   0.33\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF8E2400>  Proportion switching:  0.125   Proportion winning:   0.38\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF8E2588>  Proportion switching:  0.250   Proportion winning:   0.41\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF8DF7B8>  Proportion switching:  0.375   Proportion winning:   0.46\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF911278>  Proportion switching:  0.500   Proportion winning:   0.50\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF821358>  Proportion switching:  0.625   Proportion winning:   0.53\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF82DF98>  Proportion switching:  0.750   Proportion winning:   0.58\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF846A90>  Proportion switching:  0.875   Proportion winning:   0.64\n",
      "<qiskit._quantumcircuit.QuantumCircuit object at 0x000001D6CF84F7F0>  Proportion switching:  1.000   Proportion winning:   0.68\n",
      "ibmq_qasm_simulator shots 1024 end time 09/10/2018 09:54:03\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Advice: \n",
      "\n",
      "                  Thou Shalt Not Stick\n"
     ]
    }
   ],
   "source": [
    "# Illustrating different strategies\n",
    "xdat = []\n",
    "ydat = []\n",
    "observable = {'0000000000000000': 0, '0000000000010000': 1}\n",
    "shots = 1024\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(backend, \"shots\",  shots, \"starting time\", time_exp)\n",
    "\n",
    "for i in range(9) :\n",
    "    strategies = QuantumCircuit(q, c, name='strategies')\n",
    "    Prob = i/8\n",
    "    lambda_s = 2*np.arcsin(np.sqrt(Prob))\n",
    "    strategies.rx(lambda_s,q[13])\n",
    "    strategies.cx(q[13],q[4])\n",
    "    strategies.measure(q[4] , c[4]);\n",
    "    statploti = \"statplot\"+str(i)\n",
    "    statploti = QuantumCircuit(q,c, name=statploti)\n",
    "    statploti = twin+Toffoli+strategies\n",
    "    result = execute(statploti, backend=backend, shots=shots)\n",
    "    loop_average=(result.result().average_data(statploti,observable))\n",
    "    print(statploti,\" Proportion switching: %6.3f\" % Prob, \"  Proportion winning: %6.2f\" % loop_average)\n",
    "    ydat.append(loop_average)\n",
    "    xdat.append(Prob)\n",
    "    \n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(backend, \"shots\",  shots, \"end time\", time_exp)   \n",
    "plt.plot(xdat, ydat, 'ro')\n",
    "plt.grid()\n",
    "plt.ylabel('Probability of Winning', fontsize=12)\n",
    "plt.xlabel(r'Probability of Switching', fontsize=12)\n",
    "plt.show()\n",
    "print(\"Our Advice: \\n\")\n",
    "y_aver = []\n",
    "for j in range(0,7,3) :\n",
    "    y_aver.append((ydat[j] + ydat[j+1] +ydat[j+2])/3)\n",
    "\n",
    "if y_aver[0] == max(y_aver) :\n",
    "    print(\"                  Thou Shalt Not Switch\") \n",
    "\n",
    "elif y_aver[2] == max(y_aver) :\n",
    "    print(\"                  Thou Shalt Not Stick\")\n",
    "    \n",
    "else:\n",
    "    print(\"          Just follow the intuition of the moment\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concluding remarks:\n",
    "\n",
    "The model presented here is a stand alone solution to the Monty Hall problem. All scenarios of the game remain in the realm of possibility as long as a measurement is not performed.\n",
    "\n",
    "This model is further characterized by the use of multi-qubit gates. A circuit portion that creates a W state can be considered in its entirety as a three-qubit gate, which could be coined a $W$ gate. In the present case, two $W$ gates followed by three $C3$ gates make it possible to carry out the circuit.\n",
    "\n",
    "The Monty Hall problem has a well-known classical solution, but nothing prevents us from imagining that this approach may be useful for certain problems for which a solution is impossible to achieve within a reasonable time by the conventional means of numerical calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
